import formual
import screen_data
import pandas as pd
import numpy as np
import datetime
import math

class SameMultiobject():
    def __init__(self):
        self.session_len_data=[]#每个雷达的航迹总数和各个批号[批号，航迹1数据，航迹2数据。。。。]
        self.concate_data=np.array([])#航迹的初始数据（未经过标准化处理）
        self.tracks_data=np.array([])#航迹的初始数据（经过标准化处理）
        # self.cos=np.array([])#相似矩阵

    def read_data(self):
        # 获取数据
        sea_target_1=pd.read_csv(r'../sensor/data/13_2021-03-20.csv',encoding='utf-8',low_memory=False)
        sea_target_2=pd.read_csv(r'../sensor/data/15_2021-03-20.csv',encoding='utf-8')

        #由于异型传感器的doa有问题，不准确，就用同型传感器代替
        doa1=formual.getDegree(sea_target_1['platform_lat'],sea_target_1['platform_lng'],sea_target_1['lat'],sea_target_1['lng'])
        doa2=formual.getDegree(sea_target_2['platform_lat'],sea_target_2['platform_lng'],sea_target_2['lat'],sea_target_2['lng'])
        sea_target_1["doa"]=doa1
        sea_target_2["doa"]=doa2
        sea_target_1.to_csv("data/13_2021-03-20.csv",index=False)
        sea_target_2.to_csv("data/15_2021-03-20.csv",index=False)
    def process_data(self,begin_time,end_time,sea_target_1,sea_target_2):
        # 对数据进行筛选(这是对轨迹的相似分析的字段提取
        # df1 = sea_target_1[(sea_target_1['time'] >= begin_time)
        #                    & (sea_target_1['time'] <= end_time)][
        #     ['system_dnc_session', 'time', 'lat', 'lng', 'heading', 'speed']]
        # # 方位传感器：对应我那边的字段是：批号、时间、方位
        # df2 = sea_target_2[(sea_target_2['time'] >= begin_time)
        #                    & (sea_target_2['time'] <= end_time)][
        #     ['system_dnc_session', 'time', 'lat', 'lng', 'heading', 'speed']]
        # ais：对应我那边的字段是：批号、时间、轨迹（将经纬度转换成方位）
        df1 = sea_target_1[(sea_target_1['time'] >= begin_time)
                           & (sea_target_1['time'] <= end_time)][
            ['system_dnc_session', 'time', 'doa']]
        df2=sea_target_2[(sea_target_2['time'] >= begin_time)
                           & (sea_target_2['time'] <= end_time)][
            ['system_dnc_session', 'time', 'doa']]
        fal=(len(df1)>0 and len(df2)>0)#在同一个时间内两雷达都要有数据，不然无法进行数据合批
        if fal:
            time=datetime.datetime.strptime(begin_time,"%Y-%m-%d %H:%M:%S")
            time2=datetime.datetime.strptime(end_time,"%Y-%m-%d %H:%M:%S")
            m=math.floor((time2-time).seconds/600)#每10分钟取一段数据，所以一个小时分成6段/为什么不是按分钟去除，可能是为了精确到秒
            # 数据进行分段处理
            df1=screen_data.format_data(df1,begin_time,m)#把一传感器的航迹数据按批号分组统计特性
            df2=screen_data.format_data(df2,begin_time,m)
            df1_dnc=df1[0]#取出每个雷达所有航迹的批号
            df2_dnc=df2[0]

            #包含数组的长度和批号
            df1_data=[]
            df1_data.append(len(df1))
            for i in df1_dnc:
                df1_data.append(i)
            df2_data=[]
            df2_data.append(len(df2))
            for i in df2_dnc:
                df2_data.append(i)
            self.session_len_data.append(df1_data)
            self.session_len_data.append(df2_data)

            self.concate_data=pd.DataFrame(np.concatenate((df1,df2),axis=0))#合并数据
            #数据标准化处理
            self.tracks_data=formual.max_min(self.concate_data.loc[:,1:])#去除航迹批号
        else:
            print('在此时间内，两雷达里有一雷达数据缺失无法进行数据合批，请查看数据源....')
        return fal
        #换成B型灰色关联度分析算法
        #还有个三角形隶属函数的实现
    def same_matrix(self):#获取航迹相似矩阵
        print('begin same_matrix...')
        #夹角余弦
        cos=formual.cosine_similarity(self.tracks_data,self.tracks_data)
        self.cos=cos
        #欧式距离
        distance=formual.get_d_mat(self.tracks_data)
        fuz=formual.get_fuz_sim_mat(distance)
        self.fuz=fuz
        #灰度
        gray=formual.GRA(self.tracks_data)
        self.gray=gray

    def equivalence_matrix(self):#用平方法求等价矩阵
        print('begin equivalence_matrix...')
        matrix=formual.final_fuz_eql_mat(self.cos)
        return matrix

    def relevant_matrix(self,matrix_data,lam):#求lam截等价矩阵
        print('begin relevant_matrix...')
        matrix=formual.relevant_r(matrix_data,lam)
        return matrix

    def block_matrix(self,matrix_data,r_m,r_n):#矩阵进行分块
        """
        r_m,r_n参数：例如，r_m=2,r_n=1 返回雷达2和雷达1的航迹相关性矩阵
        """
        print('begin block_matrix ....')
        dic={'10':0}
        for i in range(len(self.session_len_data)):
            dic[f'l{i+1}']=self.session_len_data[i][0]
        m1=sum([dic[f'l{i}'] for i in range(r_m+1)])
        m2=sum([dic[f'l{i}'] for i in range(r_m)])
        n1=sum([dic[f'l{i}'] for i in range(r_n+1)])
        n2=sum(dic[f'l{i}'] for i in range(r_n))
        matrix=matrix_data[m2:m1,n2:n1]
        return matrix

    def find_relation_data(self,data,r_m,r_n):#找到相关航迹对
        print('begin find relation data...')
        relation_data=screen_data.relation_data(data,self.session_len_data,r_m,r_n)
        return relation_data

    def analysis_data(self,relation_data,k):#对数据进行进一步筛选分析
        final_data=screen_data.analysis(self.concate_data,relation_data,k)
        print('相关联的航迹对为：',final_data)

if __name__=='__main__':
    #分析数据的开始时间
    date_time='2021-03-20 00:00:00'
    #分析的那两个雷达之间的数据
    r_m=2
    r_n=1
    # 分时间段进行数据合批（暂定12小时）
    # 时间范围更改一下
    for _ in range(0,12):
        sea_target_1=pd.read_csv(r'../sensor/data/13_2021-0320.csv')
        sea_target_2=pd.read_csv(r'../sensor/data/15_2021-0320.csv')
        m=SameMultiobject()
        # m.read_data()#只读取一次就好
        begin_time=screen_data.time_add(date_time,_*6)#n个一小时
        end_time=screen_data.time_add(begin_time,6)#一小时

        fal=m.process_data(begin_time=begin_time,end_time=end_time,sea_target_1=sea_target_1,sea_target_2=sea_target_2)
        if fal:
            m.same_matrix()#相似矩阵
            eq_matrix=m.equivalence_matrix()#等价矩阵
            re_matrix=m.relevant_matrix(eq_matrix,0.70)#lam截矩阵
            matrix_21=m.block_matrix(re_matrix,r_m,r_n)#分块矩阵
            relation_data=m.find_relation_data(matrix_21,r_m,r_n)#找到相关航迹对
            final_raelation_data=m.analysis_data(relation_data,1)#对航迹对做距离上的判断阈值为2/方位角的阈值1
        print('------------------------------------')









